{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "71e6d8fe-84c4-47d7-8fd7-f6a66fed72e1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports \n",
    "import os\n",
    "import json\n",
    "import operator\n",
    "import pandas as pd\n",
    "from io import StringIO\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import random\n",
    "\n",
    "# settings\n",
    "BotHash = \"BEEB1E1549DDD01226DC2FC912ABAE49\"\n",
    "BotName = \"PokerShark2\"\n",
    "SB = 10\n",
    "\n",
    "# players\n",
    "Players = ['PokerShark1']\n",
    "\n",
    "# helper functions\n",
    "def prettyPrint(*arguments):\n",
    "    out = ''\n",
    "    for arg in arguments:\n",
    "        space = (30-len(arg)) * \" \"\n",
    "        out += arg + space\n",
    "    print(out)\n",
    "\n",
    "# gets an array of paths to player games\n",
    "def getGamesPath(playerName):\n",
    "    return [os.path.join(playerName,f) for f in os.listdir(playerName) if not f.startswith('.')]\n",
    "\n",
    "# Load game as json object.\n",
    "def loadGame(path):\n",
    "    with open(path) as f:\n",
    "        g = json.load(f)\n",
    "        # Throw if game not logged by the current version of the bot\n",
    "        if g[\"BotHash\"] != BotHash:\n",
    "            #raise Exception(\"BotHash does not match: \" + g[\"BotHash\"])\n",
    "            pass\n",
    "        return g\n",
    "\n",
    "# game statistics\n",
    "def getGamesCount(playerName):\n",
    "    # returns number of games played against the given player.\n",
    "    return len(getGamesPath(playerName))\n",
    "\n",
    "def getGameResultForPlayer(game, playerName):\n",
    "    # returns game result for given player.\n",
    "    results = game[\"Results\"]\n",
    "    maxStack = 0\n",
    "    hasMax = []\n",
    "    # find max stack\n",
    "    for result in results:\n",
    "        if maxStack < result[\"Stack\"]:\n",
    "            maxStack = result[\"Stack\"]\n",
    "            hasMax= [result[\"Player\"][\"Name\"]]\n",
    "        elif maxStack == result[\"Stack\"]:\n",
    "            hasMax.append(result[\"Player\"][\"Name\"])\n",
    "    # find player result\n",
    "    if playerName in hasMax:\n",
    "        if len(hasMax) > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonGamesCount(playerName):\n",
    "    # returns number of games won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'W':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewGamesCount(playerName):\n",
    "    # return number of games drew against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'D':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getLostGamesCount(playerName):\n",
    "    # return number of games lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        result = getGameResultForPlayer(game, BotName)\n",
    "        if result == 'L':\n",
    "            count += 1\n",
    "    return count\n",
    "\n",
    "def getEndStack(playerName):\n",
    "    # return sum of the stack after the games.\n",
    "    s = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for result in game[\"Results\"]:\n",
    "            if result[\"Player\"][\"Name\"] == BotName:\n",
    "                s += result[\"Stack\"]\n",
    "    return s\n",
    "            \n",
    "# round statistics\n",
    "def getRoundsCount(playerName):\n",
    "    # returns number of rounds played against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        count += len(game[\"Rounds\"])\n",
    "    return count\n",
    "\n",
    "def GetRoundResultForPlayer(r, playerName):\n",
    "    results = r[\"Winner\"]\n",
    "    winners = len(results)\n",
    "    won = False\n",
    "    for result in results:\n",
    "        if playerName == result[\"Name\"]:\n",
    "            won = True\n",
    "            break\n",
    "    if won:\n",
    "        if winners > 1:\n",
    "            return 'D'\n",
    "        else:\n",
    "            return 'W'\n",
    "    return 'L'\n",
    "\n",
    "def getWonRoundsCount(playerName):\n",
    "    # returns number of rounds won against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'W':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getDrewRoundsCount(playerName):\n",
    "    # return number of games rounds against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'D':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def getLostRoundsCount(playerName):\n",
    "    # return number of rounds lost against the given player.\n",
    "    count = 0\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            result = GetRoundResultForPlayer(r, BotName)\n",
    "            if result == 'L':\n",
    "                count += 1\n",
    "    return count\n",
    "\n",
    "def endedBeforeShowdown(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\":\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def botFolded(r):\n",
    "    # returns true if one of the two players folded.\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] == \"Fold\" and action[\"PlayerName\"] == BotName:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "def getPaid(r,playerName):\n",
    "    # returns amount paid by player\n",
    "    amount = 0\n",
    "    # blinds\n",
    "    sbp = r['SmallBlindPosition']\n",
    "    for p in range(len(r['Players'])):\n",
    "        if r['Players'][p]['Name'] == playerName:\n",
    "            if p == sbp:\n",
    "                amount += SB\n",
    "            else:\n",
    "                amount += SB + SB\n",
    "    # calls and raises\n",
    "    for action in r[\"History\"]:\n",
    "        if action[\"Type\"] != \"Fold\" and action[\"PlayerName\"] == playerName:\n",
    "            amount += action[\"Amount\"]\n",
    "    return amount\n",
    "\n",
    "# winning statistics\n",
    "def getNonShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if endedBeforeShowdown(r):\n",
    "                if botFolded(r):\n",
    "                    line -= getPaid(r,BotName)\n",
    "                else:\n",
    "                    line += getPaid(r,playerName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getShowdownWinningsLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if not endedBeforeShowdown(r):\n",
    "                # if bot won\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                    line += getPaid(r,playerName)\n",
    "                if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                    line -= getPaid(r,BotName)\n",
    "                \n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def getStackLine(playerName):\n",
    "    # line goes down each time bot fold, and up each time your opponent fold.\n",
    "    x = [0]\n",
    "    y = [0]\n",
    "    line = 0\n",
    "    count = 1\n",
    "    files = getGamesPath(playerName)\n",
    "    for file in files:\n",
    "        game = loadGame(file)\n",
    "        for r in game[\"Rounds\"]:\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'W':\n",
    "                line += getPaid(r,playerName)\n",
    "            if GetRoundResultForPlayer(r, BotName) == 'L':\n",
    "                line -= getPaid(r,BotName)\n",
    "            x.append(count)\n",
    "            y.append(line)\n",
    "            count += 1\n",
    "    return (x,y)\n",
    "\n",
    "def plotWinnings(playerName):\n",
    "    # NonShowdownWinningsLine\n",
    "    x,y = getNonShowdownWinningsLine(playerName)\n",
    "    fig, ax = plt.subplots()\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Non-showdown winnings', c='r')\n",
    "    # ShowdownWinningsLine\n",
    "    x,y = getShowdownWinningsLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Showdown winnings', c='b')\n",
    "    # Stack\n",
    "    x,y = getStackLine(playerName)\n",
    "    xpoints = np.array(x)\n",
    "    ypoints = np.array(y)\n",
    "    ax.plot(xpoints, ypoints,linewidth=1,label='Winnings', c='g')\n",
    "    # show plot\n",
    "    y_max = np.abs(ax.get_ylim()).max()\n",
    "    ax.set_ylim(ymin=-y_max, ymax=y_max)\n",
    "    ax.set_xlim(left=0)\n",
    "    plt.legend()\n",
    "    plt.grid(linestyle = '--', linewidth = 0.5)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# Print Results\n",
    "def PrintResult():\n",
    "    for player in Players:\n",
    "        prettyPrint(\"Results against:\", player)\n",
    "        # game statistics\n",
    "        n = getGamesCount(player)\n",
    "        w = getWonGamesCount(player)\n",
    "        d = getDrewGamesCount(player)\n",
    "        l = getLostGamesCount(player)\n",
    "        prettyPrint(\"number of games:\",str(n))\n",
    "        prettyPrint(\"number of games won:\", str(w) , \"{:.1f}\".format(w*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games drew:\", str(d), \"{:.1f}\".format(d*100/n) + \"%\")\n",
    "        prettyPrint(\"number of games lost:\", str(l), \"{:.1f}\".format(l*100/n) + \"%\")\n",
    "        # round statistics\n",
    "        rn = getRoundsCount(player)\n",
    "        rw = getWonRoundsCount(player)\n",
    "        rd = getDrewRoundsCount(player)\n",
    "        rl = getLostRoundsCount(player)\n",
    "        prettyPrint(\"number of rounds:\",str(rn))\n",
    "        prettyPrint(\"number of rounds won:\", str(rw) , \"{:.1f}\".format(rw*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds drew:\", str(rd), \"{:.1f}\".format(rd*100/rn) + \"%\")\n",
    "        prettyPrint(\"number of rounds lost:\", str(rl), \"{:.1f}\".format(rl*100/rn) + \"%\")\n",
    "        # winnings\n",
    "        prettyPrint(\"starting stack:\", str(1000 * n))\n",
    "        prettyPrint(\"end stack:\", str(getEndStack(player)))\n",
    "        prettyPrint(\"win/loss:\", str(getEndStack(player) - (1000 * n)  ))\n",
    "        prettyPrint(\"WPH:\", str((getEndStack(player) - (1000 * n)) / (rn*10)))\n",
    "        plotWinnings(player)\n",
    "        # end\n",
    "        print('-------------------------------------------------------------')\n",
    "        \n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "f45a61bb-8373-4bd1-8fd6-b85a124517bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seeking player:\n",
      "Results against:              PokerShark2                   \n",
      "number of games:              100                           \n",
      "number of games won:          89                            89.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         11                            11.0%                         \n",
      "number of rounds:             9925                          \n",
      "number of rounds won:         6400                          64.5%                         \n",
      "number of rounds drew:        2                             0.0%                          \n",
      "number of rounds lost:        3523                          35.5%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    135920.0                      \n",
      "win/loss:                     35920.0                       \n",
      "WPH:                          0.36191435768261965           \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n",
      "risk-averse player:\n",
      "Results against:              PokerShark1                   \n",
      "number of games:              100                           \n",
      "number of games won:          11                            11.0%                         \n",
      "number of games drew:         0                             0.0%                          \n",
      "number of games lost:         89                            89.0%                         \n",
      "number of rounds:             9925                          \n",
      "number of rounds won:         3523                          35.5%                         \n",
      "number of rounds drew:        2                             0.0%                          \n",
      "number of rounds lost:        6400                          64.5%                         \n",
      "starting stack:               100000                        \n",
      "end stack:                    64080.0                       \n",
      "win/loss:                     -35920.0                      \n",
      "WPH:                          -0.36191435768261965          \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "seeking = \"PokerShark1\"\n",
    "averse = \"PokerShark2\"\n",
    "\n",
    "# print seeking stats\n",
    "print(\"seeking player:\")\n",
    "BotName = seeking\n",
    "os.rename(\"games\", averse)\n",
    "Players = [averse]\n",
    "PrintResult()\n",
    "\n",
    "# print Risk averse stats\n",
    "print(\"risk-averse player:\")\n",
    "BotName = averse\n",
    "os.rename(averse, seeking)\n",
    "Players = [seeking]\n",
    "PrintResult()\n",
    "os.rename(seeking, \"games\")\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecb3052c-f407-4cc7-a654-f4b4264b1b01",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
